package main

import (
	"fmt"
	"strconv"
	"strings"
)

// 字符串常用方法一
func main() {

	testLen()

	testPrintChar()

	testString4Int()

	testInt2String()

	testString2ByteSlice()

	testByteSlice2String()

	testTenRadix2Other()

	testContains()

	testCountSub()

	testEquals()

	testIndex()
}

// testLen
//
//	@Description: 内置函数 builtin golang 统一按照utf-8  一个中文3个字节
func testLen() {
	fmt.Println("---------------- 字符串长度 ----------------")
	var str string = "hello"
	fmt.Printf("hello-长度:%d \n", len(str))
	var str2 string = "中国"
	fmt.Printf("中国-长度:%d \n", len(str2))

}

// testPrintChar
//
//	@Description: 遍历字符串
func testPrintChar() {
	fmt.Println("---------------- 遍历字符串 ----------------")
	var str = "hello北京"
	for i := 1; i < len(str); i++ {
		fmt.Printf("%c  \n", str[i])
	}
	fmt.Println()

	//在 Go 语言中，[]rune 是一个 rune 类型的切片，用于表示 Unicode 字符序列。
	//rune 类型实际上是一个别名，代表 int32，用于存储 Unicode 码点。
	//使用 []rune 可以方便地处理多字节字符和 Unicode 字符串。
	//~
	//将string显示转换为[]rune
	r := []rune(str) //[]rune  字符切片
	for i := 1; i < len(r); i++ {
		fmt.Printf("%c \n", r[i])
	}
	//b1 := []byte(str)
	//for i := 1; i < len(b1); i++ {
	//	fmt.Printf("%c \n", b1[i])
	//}
}

// testString4Int
//
//	@Description: 字符串转int
func testString4Int() {
	fmt.Println("---------------- 字符串转int ----------------")
	var str string = "123"
	i, _ := strconv.Atoi(str)
	fmt.Printf("字符串：%s 转int:%d  type=%T \n", str, i, i)
	//字符串：123 转int:123  type=int

	//10 基数，表示10进制
	//64 位数大小，表示返回的整数类型。这里指定为 64，表示返回 int64 类型的整数
	parseInt, _ := strconv.ParseInt(str, 10, 64)
	fmt.Printf("字符串：%s 转int:%d  type=%T \n", str, parseInt, parseInt)
	//字符串：123 转int:123  type=int64

	var str1 string = "hello"
	n, err := strconv.Atoi(str1)
	if err != nil {
		fmt.Printf("字符串：%s 转int error  \n", str1)
	} else {
		fmt.Printf("字符串：%s 转int:%d  \n", str1, n)
	}

}

// testInt2String
//
//	@Description: int 转string
func testInt2String() {
	fmt.Println("---------------- int 转string ----------------")
	var num = 10
	str := strconv.Itoa(num)
	fmt.Printf("数字：%d 转string %s \n", num, str)
	//数字：10 转string 10

	//8 表示8进制
	formatInt := strconv.FormatInt(int64(num), 8)
	fmt.Printf("数字：%d 转string %s \n", num, formatInt)

	//数字：10 转string 12
	sprintf := fmt.Sprintf("%d", num)
	fmt.Printf("数字：%d 转string %s \n", num, sprintf)
}

// testString2ByteArray
//
//	@Description: string 转byte切片
func testString2ByteSlice() {
	fmt.Println("---------------- string 转byte切片 ----------------")
	var str = "hello"
	var bytes = []byte(str)
	fmt.Printf("字符串： %s 转byte切片 %v \n", str, bytes)
	//字符串： hello 转byte切片 [104 101 108 108 111]

	var runes = []rune(str)
	fmt.Printf("字符串： %s 转byte切片 %v \n", str, runes)
	//字符串： hello 转byte切片 [104 101 108 108 111]

}

// testByteSlice2String
//
//	@Description: byte切片 转string
func testByteSlice2String() {
	fmt.Println("---------------- byte切片 转string ----------------")
	var bytes = []byte{97, 98, 99}
	var str string = string(bytes)

	fmt.Printf("byte数组： %v 转字符串 %s \n", bytes, str)
	//byte数组： [97 98 99] 转字符串 abc

}

// testTenRadix2Other
//
//	@Description: 10进制转其他进制字符串
func testTenRadix2Other() {
	fmt.Println("---------------- 10进制转其他进制字符串 ----------------")
	var num int64 = 88
	//2表示进制
	s1 := strconv.FormatInt(num, 2)
	fmt.Printf("%d转二进制：%s  type=%T\n", num, s1, s1)
	//88转二进制：1011000  type=string

	s2 := strconv.FormatInt(num, 8)
	fmt.Printf("%d转八进制：%s  type=%T \n", num, s2, s2)
	//88转八进制：130  type=string

	s3 := strconv.FormatInt(num, 16)
	fmt.Printf("%d转十六进制：%s  type=%T \n", num, s3, s3)
	//88转十六进制：58  type=string

}

// testContains
//
//	@Description: 一个字符串是否包含另一个字符串
func testContains() {
	fmt.Println("---------------- 一个字符串是否包含另一个字符串 ----------------")
	var str string = "hello"
	var sub string = "he"
	contains := strings.Contains(str, sub)
	fmt.Printf("%s 是否包含%s：%t \n", str, sub, contains)
	//hello 是否包含he：true

}

// testCountSub
//
//	@Description: 一个字符串中有多少个另一个字符串
func testCountSub() {
	fmt.Println("---------------- 一个字符串中有多少个另一个字符串 ----------------")
	var str string = "chinese_chinese"
	var sub string = "chin"
	count := strings.Count(str, sub)
	fmt.Printf("%s 中有%d个%s \n", str, count, sub)
	//chinese_chinese 中有2个chin

}

// testEquals
//
//	@Description: 字符串是否相等区分大小写
func testEquals() {
	fmt.Println("---------------- 字符串是否相等区分大小写 ----------------")
	var str1 string = "abc"
	var str2 string = "ABc"
	fold := strings.EqualFold(str2, str1)
	fmt.Printf("%s %s 是否相等：%t  \n", str1, str2, fold)
	//abc ABc 是否相等：true

	fmt.Printf("%s == %s : %t  \n", str1, str2, str1 == str2)
	//abc == ABc : false

}

// testIndex
//
//	@Description: 一个字符串中另一个字符串出现的index 没有返回-1
func testIndex() {
	fmt.Println("---------------- 一个字符串中另一个字符串出现的index 没有返回-1 ----------------")
	var str string = "chinese"
	var sub1 string = "chinese"
	var sub2 string = "abc"

	index1 := strings.Index(str, sub1)
	fmt.Printf("%s在%s 出现的index: %d  \n", sub1, str, index1)
	//chinese在chinese 出现的index: 0

	index2 := strings.Index(str, sub2)
	fmt.Printf("%s在%s 出现的index: %d  \n", sub2, str, index2)
	//abc在chinese 出现的index: -1

}
